package mws;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(0,1,5, TimeUnit.SECONDS,new LinkedBlockingQueue<>(), x->{

            return new Thread(x);

        });

        threadPoolExecutor.submit(()->{
            System.out.println("asdaf");
        });

//        // 测试数组
//        int[] array = {12, 11, 13, 5, 6, 7};
//
//        // 测试快速排序
//        int[] quickSortArray = array.clone();// 降序
//        quickSort(quickSortArray, 0, quickSortArray.length );
//        System.out.println("快速排序结果:");
//        printArray(quickSortArray);
//
//        // 测试堆排序
//        int[] heapSortArray = array.clone();
//        heapSort(heapSortArray,0,heapSortArray.length);
//        System.out.println("堆排序结果:");
//        printArray(heapSortArray);
//
//        // 测试归并排序
//        int[] mergeSortArray = array.clone();// 降序
//        mergeSort(mergeSortArray, 0, mergeSortArray.length );
//        System.out.println("归并排序结果:");
//        printArray(mergeSortArray);
    }

    private static void mergeSort(int[] mergeSortArray, int i, int i1) {
        if(i < i1 ){

        }
    }
    /**
     * 将无序数组构建为最大堆
     * @param arr 待转换的数组
     */
    public static void buildMaxHeap(int[] arr) {
        if (arr == null || arr.length <= 1) {
            return; // 空数组或单个元素无需处理，已是堆
        }

        int n = arr.length;
        // 从最后一个非叶子节点开始，向前依次进行堆调整
        // 最后一个非叶子节点的索引 = (n/2) - 1（数组索引从0开始）
        for (int i = (n / 2) - 1; i >= 0; i--) {
            heapify(arr, n, i);
        }
    }

    /**
     * 堆调整操作：确保以i为根的子树符合最大堆特性
     * @param arr 数组
     * @param heapSize 堆的大小（当前需要处理的元素范围）
     * @param i 要调整的节点索引
     */
    private static void heapify(int[] arr, int heapSize, int i) {
        int largest = i; // 初始化最大值为当前节点
        int left = 2 * i + 1; // 左子节点索引
        int right = 2 * i + 2; // 右子节点索引

        // 如果左子节点大于当前最大值，更新最大值索引
        if (left < heapSize && arr[left] > arr[largest]) {
            largest = left;
        }

        // 如果右子节点大于当前最大值，更新最大值索引
        if (right < heapSize && arr[right] > arr[largest]) {
            largest = right;
        }

        // 如果最大值不是当前节点，需要交换并递归调整子树
        if (largest != i) {
            // 交换当前节点与最大值节点
            int temp = arr[i];
            arr[i] = arr[largest];
            arr[largest] = temp;

            // 递归调整被影响的子树
            heapify(arr, heapSize, largest);
        }
    }

    private static void heapSort(int[] heapSortArray,int start,int end) {
        if(start == end - 1)
            return;
        int endPoint = end - 1;
        heapSort(heapSortArray,start,end);
    }

    private static void quickSort(int[] quickSortArray, int i, int i1) {
   // 从小到大 排序


 if(i < i1 && i < quickSortArray.length) {
     int[] mid = new int[i1 - i];
     int midNum = quickSortArray[i];
     int start = 0;
     int back = mid.length - 1;
     for (int j = i + 1; j < i1  && j < quickSortArray.length; j++) {
         if(quickSortArray[j] < midNum){
             mid[start++] = quickSortArray[j];
         }else {
             mid[back] = quickSortArray[j];
             --back;
         }

     }
     mid[start] = midNum; // 中间值放到正确位置
     for (int j = i; j < i1; j++) {
         quickSortArray[j] = mid[j - i];
     }

     quickSort(quickSortArray,i,i+start );
     quickSort(quickSortArray,i+start+1,i1);


 }

    }

    // 打印数组
    public static void printArray(int[] arr) {
        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println();
    }
}
